using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using AjaxControlToolkit;

namespace AjaxControlToolkit.Models.MSTest
{
	
    public partial class MultiHandleSliderExtenderTests
    {


        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Minimum_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Minimum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Minimum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Minimum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Minimum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Minimum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Minimum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Minimum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Minimum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Minimum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Minimum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Maximum_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Maximum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Maximum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Maximum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Maximum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Maximum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Maximum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Maximum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Maximum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Maximum = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Maximum);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Length_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Length = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Length);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Length = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Length);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Length = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Length);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Length = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Length);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Length = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Length);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Steps_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Steps = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Steps);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Steps = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Steps);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Steps = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Steps);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Steps = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Steps);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Steps = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Steps);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ShowInnerRail_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ShowInnerRail = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ShowInnerRail);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ShowInnerRail = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ShowInnerRail);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_RaiseChangeOnlyOnMouseUp_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.RaiseChangeOnlyOnMouseUp = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.RaiseChangeOnlyOnMouseUp);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.RaiseChangeOnlyOnMouseUp = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.RaiseChangeOnlyOnMouseUp);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableInnerRangeDrag_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableInnerRangeDrag = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableInnerRangeDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableInnerRangeDrag = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableInnerRangeDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableRailClick_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableRailClick = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableRailClick);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableRailClick = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableRailClick);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_IsReadOnly_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.IsReadOnly = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.IsReadOnly);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.IsReadOnly = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.IsReadOnly);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableKeyboard_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableKeyboard = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableKeyboard);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableKeyboard = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableKeyboard);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableMouseWheel_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableMouseWheel = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableMouseWheel);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableMouseWheel = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableMouseWheel);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Increment_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Increment = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Increment);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Increment = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Increment);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Increment = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Increment);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Increment = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Increment);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Increment = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Increment);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableHandleAnimation_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableHandleAnimation = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableHandleAnimation);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableHandleAnimation = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableHandleAnimation);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ShowHandleHoverStyle_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ShowHandleHoverStyle = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ShowHandleHoverStyle);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ShowHandleHoverStyle = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ShowHandleHoverStyle);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ShowHandleDragStyle_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ShowHandleDragStyle = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ShowHandleDragStyle);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ShowHandleDragStyle = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ShowHandleDragStyle);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_HandleAnimationDuration_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Single expectedValue;
        
            
            try
            {
                expectedValue = Single.MinValue;
                objectUnderTest.HandleAnimationDuration = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.HandleAnimationDuration);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Single)(-1);
                objectUnderTest.HandleAnimationDuration = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.HandleAnimationDuration);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Single)0;
                objectUnderTest.HandleAnimationDuration = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.HandleAnimationDuration);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Single)1;
                objectUnderTest.HandleAnimationDuration = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.HandleAnimationDuration);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Single.MaxValue;
                objectUnderTest.HandleAnimationDuration = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.HandleAnimationDuration);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_TooltipText_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.TooltipText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipText)) || expectedValue == objectUnderTest.TooltipText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_CssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_OnClientLoad_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnClientLoad = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientLoad)) || expectedValue == objectUnderTest.OnClientLoad);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_OnClientDragStart_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnClientDragStart = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragStart)) || expectedValue == objectUnderTest.OnClientDragStart);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_OnClientDrag_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnClientDrag = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDrag)) || expectedValue == objectUnderTest.OnClientDrag);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_OnClientDragEnd_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnClientDragEnd = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientDragEnd)) || expectedValue == objectUnderTest.OnClientDragEnd);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_OnClientValueChanged_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnClientValueChanged = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnClientValueChanged)) || expectedValue == objectUnderTest.OnClientValueChanged);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_BoundControlID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.BoundControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BoundControlID)) || expectedValue == objectUnderTest.BoundControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Decimals_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Decimals = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Decimals);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Decimals = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Decimals);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Decimals = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Decimals);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Decimals = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Decimals);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Decimals = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Decimals);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_HandleCssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.HandleCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleCssClass)) || expectedValue == objectUnderTest.HandleCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_RailCssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.RailCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.RailCssClass)) || expectedValue == objectUnderTest.RailCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_HandleImageUrl_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.HandleImageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.HandleImageUrl)) || expectedValue == objectUnderTest.HandleImageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_SkinID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Enabled_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Enabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Enabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Enabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Enabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ScriptPath_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_BehaviorID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ClientState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ClientStateFieldID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableClientState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableClientState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableClientState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_TargetControlID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_Visible_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_ID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableTheming_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_EnableViewState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MultiHandleSliderExtenderTests_Property_AppRelativeTemplateSourceDirectory_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
    }
}

